use std::collections::HashMap;

fn main() {
    println!("Hello, world!");
    // 向量(Vector)是一个存放多值的单数据结构，该结构将相同类型的值线性的存放在内存中。
    // 向量是线性表，在 Rust 中的表示是 Vec<T>。
    // 向量的使用方式类似于列表(List)
    //空向量
    let v: Vec<i32> = Vec::new();
    let mut v = vec![1, 2, 4];
    v.push(8);
    v.push(16);
    v.push(32);
    v.push(64);
    for i in &v {
        println!("{}", i);
    }
    // append 方法用于将一个向量拼接到另一个向量的尾部：
    let mut v1: Vec<i32> = vec![1, 2, 4, 8];
    let mut v2: Vec<i32> = vec![16, 32, 64];
    v1.append(&mut v2);
    println!("{:?}", v1);
    let mut v = vec![1, 2, 4, 8];
    println!("{}", match v.get(0) {
        Some(value) => value.to_string(),
        None => "None".to_string()
    });
    // 因为向量的长度无法从逻辑上推断，get 方法无法保证一定取到值，所以 get 方法的返回值是
    // Option 枚举类，有可能为空。
    // 这是一种安全的取值方法，但是书写起来有些麻烦。如果你能够保证取值的下标不会超出向量下标
    // 取值范围，你也可以使用数组取值语法
    let mut v = vec![1, 2, 4, 8];
    println!("{}", v[0]);
    for i in &v {
        println!("{}", i);
    }
    //如果遍历过程中需要更改变量的值：
    for i in &mut v {
        *i += 50;
    }
    for i in &v {
        println!("{}", i);
    }
    //新建字符串
    let string = String::new();
    //基础类型转换字符串
    let one = 1.to_string();
    let float = 1.3.to_string();
    let slice = "slice".to_string();
    //字符串追加
    let mut string = String::from("run");
    string.push_str("oob");
    string.push('!');
    println!("{}", string);
    //用+号拼接字符串
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    let s3 = s1 + &s2;
    // 这个语法也可以包含字符串切片：

    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");
    let s = s1 + "-" + &s2 + "-" + &s3;
    // 使用 format! 宏：

    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");
    let s = format!("{}-{}-{}", s1, s2, s3);
    // 字符串长度：

    let s = "hello";
    let len = s.len();
    // 这里 len 的值是 5。
    println!("{}",len);
    let s = "你好";
    let len = s.len();
    println!("{}", len);
    //这里 len 的值是 6。因为中文是 UTF-8 编码的，每个字符长 3 字节，
    // 所以长度为6。但是 Rust 中支持 UTF-8 字符对象，所以如果想统计
    // 字符数量可以先取字符串为字符集合：
    let s = "hello你好";
    let len = s.chars().count();
    println!("{}", len);
    //这里 len 的值是 7，因为一共有 7 个字符。统计字符的速度
    // 比统计数据长度的速度慢得多。
    let s = String::from("hello中文");
    for c in s.chars() {
        println!("{}", c);
    }
    let s = String::from("EN中文");
    let a = s.chars().nth(2);
    println!("{:?}", a);
    //映射表
    //映射表(Map)在其他语言中广泛存在。其中应用最普遍的就是键值散列映射表
    // （Hash Map）。
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
    println!("{}",scores.get("Blue").unwrap());
    for p in scores.iter(){
        println!("{:?}",p);
    }
    scores.entry(String::from("Red")).or_insert(100);

    let mut map = HashMap::new();
    map.insert(1,"a");
    if let Some(v) = map.get_mut(&1){
        *v = "b";
    }
    println!("{:?}",map);
}
